package note_002;

public class day11 {
    /**
     * Collection:提供了一个静态方法:
     * static void sort(List list)
     * 可以对给定的集合进行自然排序(从小到大)
     *
     * Collections.sort(?);
     */

    /**
     * 排序自定义类型元素的集合
     * List<Point> list = new ArrayList<>();
     * list.add(new Point(1,2));
     *-----------------------------------------------------------------------Comparable接口
     * 当集合元素已经实现Comparable接口，但是该比较规则不满足排序需求时，也可以使用重载的sort
     * 方法临时指定一个比较规则进行排序.
     * 例如:排序字符串String.
     * List<String> list = new ArrayList<>();
     * list.add("巴拉巴拉");
     *  list.add("黑魔仙");
     */
     /*
            Collection.sort(List list)
            该方法要求集合元素必须实现可比较的接口Comparable,否则编译不通过.
            这样做对我们的程序具有侵入性。因此当不能使用该方法时就不建议使用。

            侵入性:当我们调用某个API的方法时，该方法要求我们为其修改其他地方的代码后才能工作时.
            这样的行为就是侵入性，它不利于代码的后期维护.
         */
//        Collections.sort(list);//没实现接口Comparable:定义元素之间比较大小.
    /** Collections.sort(List list):排序*/
    /** 一: 有入侵性 -> Comparator:比较器 */
//        Comparator<String> c = new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                Integer t1 = o1.length();
//                Integer t2 = o2.length();
//                return t1-t2;
//            }
//        };
//        Collections.sort(list,c);
    /** 二: 解决入侵 */
//        Collections.sort(list, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                Integer t1 = o1.length();
//                Integer t2 = o2.length();
//                return t1-t2;
//            }
//        });
    /** lambda: 表达式 */
//        Collections.sort(list,
//            (o1, o2) -> o1.length() - o2.length());
//        System.out.println(list);
    /**
     * 我们常用的集合中:ArrayList,LinkedList,HashSet都不是并发安全的。
     * 在多线程并发操作时不要使用他们.
     * 但是Collections提供了将现有的集合转换为并发安全的集合相关方法.
     */
     /*
            Collections提供了静态方法;
            static List synchronizedList(List list)
            将给定的List集合转换为一个并发安全的List集合并返回
            static Set synchronizedSet(Set set)
            将给定的Set集合转换为一个并发安全的Set集合并返回
            static Collection synchronizedCollection(Collection c)
            将给定的Collection集合转换为一个并发安全的Collection集合并返回
         */
//        list =Collections.synchronizedList(list);//创建了一个新的集合,转换为并发安全,并返回
//        System.out.println(list);
    /** forEach():集合自身的遍历元素的方式 */
//        JDK8之后，集合提供了新的遍历元素方式:forEach方法基于lambda表达式遍历.
//        list.forEach(
//                (e)->System.out.println(e)
//            );//list通过forEach传入e,在输出.
    /** lambda 支持:方法引用"::"*/
//        list.forEach(System.out::println);

    /**
     * 队列:---------------------------------------------------------队列 java.util.LinkedList.
     * java.util.Queue接口。Queue继承自Collection------------------java.util.Queue接口
     * 队列可以保存一组元素，但是存取元素必须遵循先进先出原则。
     * 常见实现类:java.util.LinkedList.
     */
    /** Queue 队列 */
//    Queue<String> queue = new LinkedList<>();
    /** boolean offer(): 入队 */
//            boolean offer(E e):队尾添元素
//            入队操作，将元素添加到队列末尾.
//            queue.offer("one");
    /** E poll(): 出队 */
//            E poll():队首出元素
//            获取队首元素，获取后该元素从队列中被移除.
    /** E peek(): 偷窥 */
//            E peek():
//            引用对手元素，获取后该元素仍然在队列中.
    /**Collection中定义*/
//        System.out.println("size:"+queue.size());
//    //可以使用新循环(迭代器)和forEach遍历
//        for(String g : queue){
//        System.out.println(g);
//    }
//        System.out.println(queue);
//        queue.forEach(q-> System.out.println(q));
//        System.out.println(queue);
//        queue.forEach(System.out::println);
//        System.out.println(queue);
//    //使用poll方法遍历(一次性的)
//        while (queue.size()>0){
//        str = queue.poll();
//        System.out.println(str);
//    }
//        System.out.println(queue);
    /**
     * java.util.Deque接口，双端队列-----------------------------java.util.Deque
     * 双端队列就是队列两端都可以做出入队的队列。
     * Deque继承自Queue，常用实现类:java.util.LinKedList.
     */

    /** offerFirst():从队首方向入队
     *offerLast():从队尾方向入队 -> boolean offer(): 入队
     * pollFirst(): 从队首方向出队 ->  E poll(): 出队
     * pollLast() 从队尾方向出队
     */

    /**
     * 栈结构: -> 双端队列
     * 栈结构可以使用双端队列完成，Deque为栈结构提供了对应的方法:push(入栈),pop(出栈)
     * 1.栈结构可以保存一组元素，但是存取元素必须遵循先进后出原则。
     * 2.通常使用栈来完成如:后退，前进这样的功能.
     */
//    Deque<String> stack = new LinkedList<>();
    /** push(入栈) */
//        stack.push("one");
    //存取元素必须遵循先进后出原则。
    /** pop(出栈) */
//    String str = stack.pop();


}
